<?php

/** Copyright (C) 2008 Guy Van den Broeck <guy@guyvdb.eu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 * or see http://www.gnu.org/
 * 
 * @ingroup DifferenceEngine
 */

/**
 * When detecting the last common parent of two nodes, all results are stored as
 * a LastCommonParentResult.
 */

include_once 'Diff.php'; 
include_once 'Nodes.php';
include_once 'Sanitizer.php';
include_once 'Xml.php';

class LastCommonParentResult {

    // Parent
    public $parent;

    // Splitting
    public $splittingNeeded = false;

    // Depth
    public $lastCommonParentDepth = -1;

    // Index
    public $indexInLastCommonParent = -1;
}

class Modification{

    const NONE = 1;
    const REMOVED = 2;
    const ADDED = 4;
    const CHANGED = 8;

    public $type;

    public $id = -1;

    public $firstOfID = false;

    public $changes;

    function __construct($type) {
        $this->type = $type;
    }

    public static function typeToString($type) {
        switch($type) {
            case self::NONE: return 'none';
            case self::REMOVED: return 'removed';
            case self::ADDED: return 'added';
            case self::CHANGED: return 'changed';
        }
    }
}

class DomTreeBuilder {

    public $textNodes = array();

    public $bodyNode;

    private $currentParent;

    private $newWord = '';

    protected $bodyStarted = false;

    protected $bodyEnded = false;

    private $whiteSpaceBeforeThis = false;

    private $lastSibling;

    private $notInPre = true;

    function __construct() {
        $this->bodyNode = $this->currentParent = new BodyNode();
        $this->lastSibling = new DummyNode();
    }

    /**
     * Must be called manually
     */
    public function endDocument() {
        $this->endWord();
        HTMLDiffer::diffDebug( count($this->textNodes) . " text nodes in document.\n" );
    }

    public function startElement($parser, $name, /*array*/ $attributes) {
        if (strcasecmp($name, 'body') != 0) {
            HTMLDiffer::diffDebug( "Starting $name node.\n" );
            $this->endWord();

            $newNode = new TagNode($this->currentParent, $name, $attributes);
            $this->currentParent->children[] = $newNode;
            $this->currentParent = $newNode;
            $this->lastSibling = new DummyNode();
            if ($this->whiteSpaceBeforeThis && !in_array(strtolower($this->currentParent->qName),TagNode::$blocks)) {
                $this->currentParent->whiteBefore = true;
            }
            $this->whiteSpaceBeforeThis = false;
            if(strcasecmp($name, 'pre') == 0) {
                $this->notInPre = false;
            }
        }
    }

    public function endElement($parser, $name) {
        if(strcasecmp($name, 'body') != 0) {
            HTMLDiffer::diffDebug( "Ending $name node.\n");
            if (0 == strcasecmp($name,'img') ||
                0 == strcasecmp($name,'br') ||
                0 == strcasecmp($name,'hr')) {
                // Insert a dummy leaf for the element
                $tag = new VisibleTagNode($this->currentParent, $name, $this->currentParent->attributes);
                $this->currentParent->children[] = $tag;
                $img->whiteBefore = $this->whiteSpaceBeforeThis;
                $this->lastSibling = $tag;
                $this->textNodes[] = $tag;
            }
            $this->endWord();
            if (!in_array(strtolower($this->currentParent->qName),TagNode::$blocks)) {
                $this->lastSibling = $this->currentParent;
            } else {
                $this->lastSibling = new DummyNode();
            }
            $this->currentParent = $this->currentParent->parent;
            $this->whiteSpaceBeforeThis = false;
            if (!$this->notInPre && strcasecmp($name, 'pre') == 0) {
                $this->notInPre = true;
            }
        } else {
            $this->endDocument();
        }
    }

    const regex = '/([\s\.\,\"\\\'\(\)\?\:\;\!\{\}\-\+\*\=\_\[\]\&\|\$]{1})/';
    const whitespace = '/^[\s]{1}$/';
    const delimiter = '/^[\s\.\,\"\\\'\(\)\?\:\;\!\{\}\-\+\*\=\_\[\]\&\|\$]{1}$/';

    public function characters($parser, $data) {

        $matches = preg_split(self::regex, htmlentities($data,ENT_NOQUOTES,'UTF-8'), -1, PREG_SPLIT_DELIM_CAPTURE);

        foreach($matches as &$word) {
            if (preg_match(self::whitespace, $word) && $this->notInPre) {
                $this->endWord();
                $this->lastSibling->whiteAfter = true;
                $this->whiteSpaceBeforeThis = true;
            } else if (preg_match(self::delimiter, $word)) {
                $this->endWord();
                $textNode = new TextNode($this->currentParent, $word);
                $this->currentParent->children[] = $textNode;
                $textNode->whiteBefore = $this->whiteSpaceBeforeThis;
                $this->whiteSpaceBeforeThis = false;
                $this->lastSibling = $textNode;
                $this->textNodes[] = $textNode;
            } else {
                $this->newWord .= $word;
            }
        }
    }

    private function endWord() {
        if ($this->newWord !== '') {
            $node = new TextNode($this->currentParent, $this->newWord);
            $this->currentParent->children[] = $node;
            $node->whiteBefore = $this->whiteSpaceBeforeThis;
            $this->whiteSpaceBeforeThis = false;
            $this->lastSibling = $node;
            $this->textNodes[] = $node;
            $this->newWord = "";
        }
    }

    public function getDiffLines() {
        return array_map(array('TextNode','toDiffLine'), $this->textNodes);
    }
}

class TextNodeDiffer {

    private $textNodes;
    public $bodyNode;

    private $oldTextNodes;
    private $oldBodyNode;

    private $newID = 0;

    private $changedID = 0;

    private $changedIDUsed = false;

    // used to remove the whitespace between a red and green block
    private $whiteAfterLastChangedPart = false;

    private $deletedID = 0;

    function __construct(DomTreeBuilder $tree, DomTreeBuilder $oldTree) {
        $this->textNodes = $tree->textNodes;
        $this->bodyNode = $tree->bodyNode;
        $this->oldTextNodes = $oldTree->textNodes;
        $this->oldBodyNode = $oldTree->bodyNode;
    }

    public function markAsNew($start, $end) {
        if ($end <= $start) {
            return;
        }

        if ($this->whiteAfterLastChangedPart) {
            $this->textNodes[$start]->whiteBefore = false;
        }

        for ($i = $start; $i < $end; ++$i) {
            $mod = new Modification(Modification::ADDED);
            $mod->id = $this->newID;
            $this->textNodes[$i]->modification = $mod;
        }
        if ($start < $end) {
            $this->textNodes[$start]->modification->firstOfID = true;
        }
        ++$this->newID;
    }

    public function handlePossibleChangedPart($leftstart, $leftend, $rightstart, $rightend) {
        $i = $rightstart;
        $j = $leftstart;

        if ($this->changedIDUsed) {
            ++$this->changedID;
            $this->changedIDUsed = false;
        }

        $changes;
        while ($i < $rightend) {
            $acthis = new AncestorComparator($this->textNodes[$i]->getParentTree());
            $acother = new AncestorComparator($this->oldTextNodes[$j]->getParentTree());
            $result = $acthis->getResult($acother);
            unset($acthis, $acother);

            if ( $result ) {
                $mod = new Modification(Modification::CHANGED);

                if (!$this->changedIDUsed) {
                    $mod->firstOfID = true;
                } else if (!is_null( $result ) && $result !== $this->changes) {
                    ++$this->changedID;
                    $mod->firstOfID = true;
                }

                $mod->changes = $result;
                $mod->id = $this->changedID;

                $this->textNodes[$i]->modification = $mod;
                $this->changes = $result;
                $this->changedIDUsed = true;
            } else if ($this->changedIDUsed) {
                ++$this->changedID;
                $this->changedIDUsed = false;
            }
            ++$i;
            ++$j;
        }
    }

    public function markAsDeleted($start, $end, $before) {

        if ($end <= $start) {
            return;
        }

        if ($before > 0 && $this->textNodes[$before - 1]->whiteAfter) {
            $this->whiteAfterLastChangedPart = true;
        } else {
            $this->whiteAfterLastChangedPart = false;
        }

        for ($i = $start; $i < $end; ++$i) {
            $mod = new Modification(Modification::REMOVED);
            $mod->id = $this->deletedID;

            // oldTextNodes is used here because we're going to move its deleted
            // elements to this tree!
            $this->oldTextNodes[$i]->modification = $mod;
        }
        $this->oldTextNodes[$start]->modification->firstOfID = true;

        $root = $this->oldTextNodes[$start]->getLastCommonParent($this->oldTextNodes[$end-1])->parent;

        $junk1 = $junk2 = null;
        $deletedNodes = $root->getMinimalDeletedSet($this->deletedID, $junk1, $junk2);

        HTMLDiffer::diffDebug( "Minimal set of deleted nodes of size " . count($deletedNodes) . "\n" );

        // Set prevLeaf to the leaf after which the old HTML needs to be
        // inserted
        if ($before > 0) {
            $prevLeaf = $this->textNodes[$before - 1];
        }
        // Set nextLeaf to the leaf before which the old HTML needs to be
        // inserted
        if ($before < count($this->textNodes)) {
            $nextLeaf = $this->textNodes[$before];
        }

        while (count($deletedNodes) > 0) {
            if (isset($prevLeaf)) {
                $prevResult = $prevLeaf->getLastCommonParent($deletedNodes[0]);
            } else {
                $prevResult = new LastCommonParentResult();
                $prevResult->parent = $this->bodyNode;
                $prevResult->indexInLastCommonParent = -1;
            }
            if (isset($nextLeaf)) {
                $nextResult = $nextLeaf->getLastCommonParent($deletedNodes[count($deletedNodes) - 1]);
            } else {
                $nextResult = new LastCommonParentResult();
                $nextResult->parent = $this->bodyNode;
                $nextResult->indexInLastCommonParent = $this->bodyNode->getNbChildren();
            }

            if ($prevResult->lastCommonParentDepth == $nextResult->lastCommonParentDepth) {
                // We need some metric to choose which way to add-...
                if ($deletedNodes[0]->parent === $deletedNodes[count($deletedNodes) - 1]->parent
                        && $prevResult->parent === $nextResult->parent) {
                    // The difference is not in the parent
                    $prevResult->lastCommonParentDepth = $prevResult->lastCommonParentDepth + 1;
                } else {
                    // The difference is in the parent, so compare them
                    // now THIS is tricky
                    $distancePrev = $deletedNodes[0]->parent->getMatchRatio($prevResult->parent);
                    $distanceNext = $deletedNodes[count($deletedNodes) - 1]->parent->getMatchRatio($nextResult->parent);

                    if ($distancePrev <= $distanceNext) {
                        $prevResult->lastCommonParentDepth = $prevResult->lastCommonParentDepth + 1;
                    } else {
                        $nextResult->lastCommonParentDepth = $nextResult->lastCommonParentDepth + 1;
                    }
                }

            }

            if ($prevResult->lastCommonParentDepth > $nextResult->lastCommonParentDepth) {
                // Inserting at the front
                if ($prevResult->splittingNeeded) {
                    $prevLeaf->parent->splitUntil($prevResult->parent, $prevLeaf, true);
                }
                $prevLeaf = $deletedNodes[0]->copyTree();
                unset($deletedNodes[0]);
                $deletedNodes = array_values($deletedNodes);
                $prevLeaf->setParent($prevResult->parent);
                $prevResult->parent->addChildAbsolute($prevLeaf,$prevResult->indexInLastCommonParent + 1);
            } else if ($prevResult->lastCommonParentDepth < $nextResult->lastCommonParentDepth) {
                // Inserting at the back
                if ($nextResult->splittingNeeded) {
                    $splitOccured = $nextLeaf->parent->splitUntil($nextResult->parent, $nextLeaf, false);
                    if ($splitOccured) {
                        // The place where to insert is shifted one place to the
                        // right
                        $nextResult->indexInLastCommonParent = $nextResult->indexInLastCommonParent + 1;
                    }
                }
                $nextLeaf = $deletedNodes[count($deletedNodes) - 1]->copyTree();
                unset($deletedNodes[count($deletedNodes) - 1]);
                $deletedNodes = array_values($deletedNodes);
                $nextLeaf->setParent($nextResult->parent);
                $nextResult->parent->addChildAbsolute($nextLeaf,$nextResult->indexInLastCommonParent);
            }
        }
        ++$this->deletedID;
    }

    public function expandWhiteSpace() {
        $this->bodyNode->expandWhiteSpace();
    }

    public function lengthNew(){
        return count($this->textNodes);
    }

    public function lengthOld(){
        return count($this->oldTextNodes);
    }
}

class HTMLDiffer {

    private static $debug = '';
    private $output;

    function htmlDiff($from, $to) {

        // Create an XML parser
        $xml_parser = xml_parser_create('');

        $domfrom = new DomTreeBuilder();

        // Set the functions to handle opening and closing tags
        xml_set_element_handler($xml_parser, array($domfrom, "startElement"), array($domfrom, "endElement"));

        // Set the function to handle blocks of character data
        xml_set_character_data_handler($xml_parser, array($domfrom, "characters"));

        HTMLDiffer::diffDebug( "Parsing " . strlen($from) . " characters worth of HTML\n" );
        if (!xml_parse($xml_parser, '<?xml version="1.0" encoding="UTF-8"?>'.Sanitizer::hackDocType().'<body>', false)
                    || !xml_parse($xml_parser, $from, false)
                    || !xml_parse($xml_parser, '</body>', true)){
            $error = xml_error_string(xml_get_error_code($xml_parser));
            $line = xml_get_current_line_number($xml_parser);
            $col = xml_get_current_column_number($xml_parser);
            HTMLDiffer::diffDebug( "XML error: $error at line $line and column $col\n" );
        }
        xml_parser_free($xml_parser);
        unset($from);

        $xml_parser = xml_parser_create('');

        $domto = new DomTreeBuilder();

        // Set the functions to handle opening and closing tags
        xml_set_element_handler($xml_parser, array($domto, "startElement"), array($domto, "endElement"));

        // Set the function to handle blocks of character data
        xml_set_character_data_handler($xml_parser, array($domto, "characters"));

        HTMLDiffer::diffDebug( "Parsing " . strlen($to) . " characters worth of HTML\n" );
        if (!xml_parse($xml_parser, '<?xml version="1.0" encoding="UTF-8"?>'.Sanitizer::hackDocType().'<body>', false)
        || !xml_parse($xml_parser, $to, false)
        || !xml_parse($xml_parser, '</body>', true)){
            $error = xml_error_string(xml_get_error_code($xml_parser));
            $line = xml_get_current_line_number($xml_parser);
            $col = xml_get_current_column_number($xml_parser);
            HTMLDiffer::diffDebug( "XML error: $error at line $line and column $col\n" );
        }
        xml_parser_free($xml_parser);
        unset($to);

        $diffengine = new WikiDiff3();
        $differences = $this->preProcess($diffengine->diff_range($domfrom->getDiffLines(), $domto->getDiffLines()));
        
        unset($xml_parser, $diffengine);

        $textNodeDiffer = new TextNodeDiffer($domto, $domfrom);

        $currentIndexLeft = 0;
        $currentIndexRight = 0;
        foreach ($differences as &$d) {
            if ($d->leftstart > $currentIndexLeft) {
                $textNodeDiffer->handlePossibleChangedPart($currentIndexLeft, $d->leftstart,
                    $currentIndexRight, $d->rightstart);
            }
            if ($d->leftlength > 0) {
                $textNodeDiffer->markAsDeleted($d->leftstart, $d->leftend, $d->rightstart);
            }
            $textNodeDiffer->markAsNew($d->rightstart, $d->rightend);

            $currentIndexLeft = $d->leftend;
            $currentIndexRight = $d->rightend;
        }
        $oldLength = $textNodeDiffer->lengthOld();
        if ($currentIndexLeft < $oldLength) {
            $textNodeDiffer->handlePossibleChangedPart($currentIndexLeft, $oldLength, $currentIndexRight, $textNodeDiffer->lengthNew());
        }
        $textNodeDiffer->expandWhiteSpace();
        
        $output = new HTMLOutput('htmldiff');

        return $output->parse($textNodeDiffer->bodyNode);
    }

    private function preProcess(/*array*/ $differences) {
        $newRanges = array();

        $nbDifferences = count($differences);
        for ($i = 0; $i < $nbDifferences; ++$i) {
            $leftStart = $differences[$i]->leftstart;
            $leftEnd = $differences[$i]->leftend;
            $rightStart = $differences[$i]->rightstart;
            $rightEnd = $differences[$i]->rightend;

            $leftLength = $leftEnd - $leftStart;
            $rightLength = $rightEnd - $rightStart;

            while ($i + 1 < $nbDifferences && self::score($leftLength,
                        $differences[$i + 1]->leftlength,
                        $rightLength,
                        $differences[$i + 1]->rightlength)
                    > ($differences[$i + 1]->leftstart - $leftEnd)) {
                $leftEnd = $differences[$i + 1]->leftend;
                $rightEnd = $differences[$i + 1]->rightend;
                $leftLength = $leftEnd - $leftStart;
                $rightLength = $rightEnd - $rightStart;
                ++$i;
            }
            $newRanges[] = new RangeDifference($leftStart, $leftEnd, $rightStart, $rightEnd);
        }
        return $newRanges;
    }

    /**
     * Heuristic to merge differences for readability.
     */
    public static function score($ll, $nll, $rl, $nrl) {
        if (($ll == 0 && $nll == 0)
                || ($rl == 0 && $nrl == 0)) {
            return 0;
        }
        $numbers = array($ll, $nll, $rl, $nrl);
        $d = 0;
        foreach ($numbers as &$number) {
            while ($number > 3) {
                $d += 3;
                $number -= 3;
                $number *= 0.5;
            }
            $d += $number;

        }
        return $d / (1.5 * count($numbers));
    }

    /**
     * Add to debug output
     * @param string $str Debug output
     */
    public static function diffDebug( $str ) {
        self :: $debug .= $str;
    }
    
    /**
     * Get debug output
     * @return string
     */
    public static function getDebugOutput() {
        return self :: $debug;
    }

}

class TextOnlyComparator {

    public $leafs = array();

    function __construct(TagNode $tree) {
        $this->addRecursive($tree);
        $this->leafs = array_map(array('TextNode','toDiffLine'), $this->leafs);
    }

    private function addRecursive(TagNode $tree) {
        foreach ($tree->children as &$child) {
            if ($child instanceof TagNode) {
                $this->addRecursive($child);
            } else if ($child instanceof TextNode) {
                $this->leafs[] = $child;
            }
        }
    }

    public function getMatchRatio(TextOnlyComparator $other) {
        $nbOthers = count($other->leafs);
        $nbThis = count($this->leafs);
        if($nbOthers == 0 || $nbThis == 0){
            return -log(0);
        }

        $diffengine = new WikiDiff3(25000, 1.35);
        $diffengine->diff($this->leafs, $other->leafs);

        $lcsLength = $diffengine->getLcsLength();

        $distanceThis = $nbThis-$lcsLength;

        return (2.0 - $lcsLength/$nbOthers - $lcsLength/$nbThis) / 2.0;
    }
}

/**
 * A comparator used when calculating the difference in ancestry of two Nodes.
 */
class AncestorComparator {

    public $ancestors;
    public $ancestorsText;

    function __construct(/*array*/ $ancestors) {
        $this->ancestors = $ancestors;
        $this->ancestorsText = array_map(array('TagNode','toDiffLine'), $ancestors);
    }

    public $compareTxt = "";

    public function getResult(AncestorComparator $other) {

        $diffengine = new WikiDiff3(10000, 1.35);
        $differences = $diffengine->diff_range($other->ancestorsText,$this->ancestorsText);

        if (count($differences) == 0){
            return null;
        }
        $changeTxt = new ChangeTextGenerator($this, $other);

        return $changeTxt->getChanged($differences)->toString();;
    }
}

class ChangeTextGenerator {

    private $ancestorComparator;
    private $other;

    private $factory;

    function __construct(AncestorComparator $ancestorComparator, AncestorComparator $other) {
        $this->ancestorComparator = $ancestorComparator;
        $this->other = $other;
        $this->factory = new TagToStringFactory();
    }

    public function getChanged(/*array*/ $differences) {
        $txt = new ChangeText;
        $rootlistopened = false;
        if (count($differences) > 1) {
            $txt->addHtml('<ul class="changelist">');
            $rootlistopened = true;
        }
        $nbDifferences = count($differences);
        for ($j = 0; $j < $nbDifferences; ++$j) {
            $d = $differences[$j];
            $lvl1listopened = false;
            if ($rootlistopened) {
                $txt->addHtml('<li>');
            }
            if ($d->leftlength + $d->rightlength > 1) {
                $txt->addHtml('<ul class="changelist">');
                $lvl1listopened = true;
            }
            // left are the old ones
            for ($i = $d->leftstart; $i < $d->leftend; ++$i) {
                if ($lvl1listopened){
                    $txt->addHtml('<li>');
                }
                // add a bullet for a old tag
                $this->addTagOld($txt, $this->other->ancestors[$i]);
                if ($lvl1listopened){
                    $txt->addHtml('</li>');
                }
            }
            // right are the new ones
            for ($i = $d->rightstart; $i < $d->rightend; ++$i) {
                if ($lvl1listopened){
                    $txt->addHtml('<li>');
                }
                // add a bullet for a new tag
                $this->addTagNew($txt, $this->ancestorComparator->ancestors[$i]);

                if ($lvl1listopened){
                    $txt->addHtml('</li>');
                }
            }
            if ($lvl1listopened) {
                $txt->addHtml('</ul>');
            }
            if ($rootlistopened) {
                $txt->addHtml('</li>');
            }
        }
        if ($rootlistopened) {
            $txt->addHtml('</ul>');
        }
        return $txt;
    }

    private function addTagOld(ChangeText $txt, TagNode $ancestor) {
        $this->factory->create($ancestor)->getRemovedDescription($txt);
    }

    private function addTagNew(ChangeText $txt, TagNode $ancestor) {
        $this->factory->create($ancestor)->getAddedDescription($txt);
    }
}

class ChangeText {

    private $txt = "";

    public function addHtml($s) {
        $this->txt .= $s;
    }

    public function toString() {
        return $this->txt;
    }
}

class TagToStringFactory {

    private static $containerTags = array('html', 'body', 'p', 'blockquote',
        'h1', 'h2', 'h3', 'h4', 'h5', 'pre', 'div', 'ul', 'ol', 'li',
        'table', 'tbody', 'tr', 'td', 'th', 'br', 'hr', 'code', 'dl',
        'dt', 'dd', 'input', 'form', 'img', 'span', 'a');

    private static $styleTags = array('i', 'b', 'strong', 'em', 'font',
        'big', 'del', 'tt', 'sub', 'sup', 'strike');

    const MOVED = 1;
    const STYLE = 2;
    const UNKNOWN = 4;

    public function create(TagNode $node) {
        $sem = $this->getChangeSemantic($node->qName);
        if (strcasecmp($node->qName,'a') == 0) {
            return new AnchorToString($node, $sem);
        }
        if (strcasecmp($node->qName,'img') == 0 ||
            strcasecmp($node->qName,'br') == 0 ||
            strcasecmp($node->qName,'hr') == 0) {
            return new NoContentTagToString($node, $sem);
        }
        return new TagToString($node, $sem);
    }

    protected function getChangeSemantic($qname) {
        if (in_array(strtolower($qname),self::$containerTags)) {
            return self::MOVED;
        }
        if (in_array(strtolower($qname),self::$styleTags)) {
            return self::STYLE;
        }
        return self::UNKNOWN;
    }
}

class TagToString {

    protected $node;

    protected $sem;

    function __construct(TagNode $node, $sem) {
        $this->node = $node;
        $this->sem = $sem;
    }

    public function getRemovedDescription(ChangeText $txt) {
        $tagDescription = "&lt;" . $this->node->qName . "&gt;";
        if ($this->sem == TagToStringFactory::MOVED) {
            $txt->addHtml( 'Moved out of: ' . $tagDescription);
        } else if ($this->sem == TagToStringFactory::STYLE) {
            $txt->addHtml( 'Style removed: <' . $this->node->qName . '>' . $tagDescription . '</' . $this->node->qName . '>');
        } else {
            $txt->addHtml( 'Removed: ' . $tagDescription);
        }
        $this->addAttributes($txt, $this->node->attributes);
        $txt->addHtml('.');
    }

    public function getAddedDescription(ChangeText $txt) {
        $tagDescription = "&lt;" . $this->node->qName . "&gt;";
        if ($this->sem == TagToStringFactory::MOVED) {
            $txt->addHtml( 'Moved into: ' . $tagDescription);
        } else if ($this->sem == TagToStringFactory::STYLE) {
            $txt->addHtml( 'Style added: <' . $this->node->qName . '>' . $tagDescription . '</' . $this->node->qName . '>');
        } else {
            $txt->addHtml( 'Added: ' . $tagDescription);
        }
        $this->addAttributes($txt, $this->node->attributes);
        $txt->addHtml('.');
    }

    protected function addAttributes(ChangeText $txt, array $attributes) {
        if (count($attributes) < 1) {
            return;
        }

        $keys = array_keys($attributes);
        $txt->addHtml(Sanitizer::normalizeCharReferences( ' with "' . $keys[0] . '" attribute as "' . $attributes[$keys[0]] . '"'));

        $nbAttributes_min_1 = count($attributes)-1;
        for ($i=1;$i<$nbAttributes_min_1;$i++) {
            $key = $keys[$i];
            $attr = $attributes[$key];
            $txt->addHtml(Sanitizer::normalizeCharReferences( ', with "' . $key . '" attribute as "' . $attr . '"'));
        }

        if ($nbAttributes_min_1 > 1) {
            $txt->addHtml(Sanitizer::normalizeCharReferences( ' and with "' . $keys[$nbAttributes_min_1] . '" attribute as "' . $attributes[$keys[$nbAttributes_min_1]] . '"'));
        }
    }

}

class NoContentTagToString extends TagToString {

    function __construct(TagNode $node, $sem) {
        parent::__construct($node, $sem);
    }

    public function getAddedDescription(ChangeText $txt) {
        $tagDescription = "&lt;" . $this->node->qName . "&gt;";
        $txt->addHtml( 'Changed to ' . $tagDescription );
        $this->addAttributes($txt, $this->node->attributes);
        $txt->addHtml('.');
    }

    public function getRemovedDescription(ChangeText $txt) {
        $tagDescription = "&lt;" . $this->node->qName . "&gt;";
        $txt->addHtml( 'Changed from ' . $tagDescription );
        $this->addAttributes($txt, $this->node->attributes);
        $txt->addHtml('.');
    }
}

class AnchorToString extends TagToString {

    function __construct(TagNode $node, $sem) {
        parent::__construct($node, $sem);
    }

    protected function addAttributes(ChangeText $txt, array $attributes) {
        if (array_key_exists('href', $attributes)) {
            $txt->addHtml(' with destination ' . htmlspecialchars($attributes['href']));
            unset($attributes['href']);
        }
        parent::addAttributes($txt, $attributes);
    }
}

/**
 * Takes a branch root and creates an HTML file for it.
 */
class HTMLOutput{

    private $prefix;
    private $handler;

    function __construct($prefix) {
        $this->prefix = $prefix;
        $this->handler = new ContentHandler();
    }

    public function parse(TagNode $node) {
        $handler = $this->handler;

        if (strcasecmp($node->qName, 'img') != 0 &&
            strcasecmp($node->qName, 'br') != 0 &&
            strcasecmp($node->qName, 'hr') != 0 &&
            strcasecmp($node->qName, 'body') != 0) {
            $handler->startElement($node->qName, $node->attributes);
        }

        $newStarted = false;
        $remStarted = false;
        $changeStarted = false;
        $changeTXT = '';

        foreach ($node->children as &$child) {
            if ($child instanceof TagNode) {
                if ($newStarted) {
                    $handler->endElement('span');
                    $newStarted = false;
                } else if ($changeStarted) {
                    $handler->endElement('span');
                    $changeStarted = false;
                } else if ($remStarted) {
                    $handler->endElement('span');
                    $remStarted = false;
                }
                $this->parse($child);
            } else if ($child instanceof TextNode) {
                $mod = $child->modification;

                if ($newStarted && ($mod->type != Modification::ADDED || $mod->firstOfID)) {
                    $handler->endElement('span');
                    $newStarted = false;
                } else if ($changeStarted && ($mod->type != Modification::CHANGED
                        || $mod->changes != $changeTXT || $mod->firstOfID)) {
                    $handler->endElement('span');
                    $changeStarted = false;
                } else if ($remStarted && ($mod->type != Modification::REMOVED || $mod ->firstOfID)) {
                    $handler->endElement('span');
                    $remStarted = false;
                }

                // no else because a removed part can just be closed and a new
                // part can start
                if (!$newStarted && $mod->type == Modification::ADDED) {
                    $attrs = array('class' => 'diff-html-added');
                    if ($mod->firstOfID) {
                        $attrs['id'] = "added-{$this->prefix}-{$mod->id}";
                    }
                    $handler->startElement('span', $attrs);
                    $newStarted = true;
                } else if (!$changeStarted && $mod->type == Modification::CHANGED) {
                    $attrs = array('class' => 'diff-html-changed');
                    if ($mod->firstOfID) {
                        $attrs['id'] = "changed-{$this->prefix}-{$mod->id}";
                    }
                    $handler->startElement('span', $attrs);

                    //tooltip
                    $handler->startElement('span', array('class' => 'tip'));
                    $handler->html($mod->changes);
                    $handler->endElement('span');

                    $changeStarted = true;
                    $changeTXT = $mod->changes;
                } else if (!$remStarted && $mod->type == Modification::REMOVED) {
                    $attrs = array('class'=>'diff-html-removed');
                    if ($mod->firstOfID) {
                        $attrs['id'] = "removed-{$this->prefix}-{$mod->id}";
                    }
                    $handler->startElement('span', $attrs);
                    $remStarted = true;
                }

                $chars = $child->text;

                if ($child instanceof VisibleTagNode) {
                    if (strcasecmp($child->qName, 'br') == 0 && ($newStarted || $changeStarted || $remStarted)) {
                        $handler->characters('&nbsp;');
                    }
                    $this->handler->element($child->qName, $child->attributes);
                } else {
                    $handler->characters($chars);
                }
            }
        }

        if ($newStarted) {
            $handler->endElement('span');
            $newStarted = false;
        } else if ($changeStarted) {
            $handler->endElement('span');
            $changeStarted = false;
        } else if ($remStarted) {
            $handler->endElement('span');
            $remStarted = false;
        }

        if (strcasecmp($node->qName, 'img') != 0 &&
            strcasecmp($node->qName, 'br') != 0 &&
            strcasecmp($node->qName, 'hr') != 0 &&
            strcasecmp($node->qName, 'body') != 0) {
            $handler->endElement($node->qName);
        }
        
        return $handler->getContent();
    }

}

class ContentHandler {

    private $string;

    function __construct() {
        $this->string = '';
    }

    function startElement($qname, /*array*/ $arguments) {
        $this->string .= Xml::openElement($qname, $arguments);
    }

    function endElement($qname){
        $this->string .= Xml::closeElement($qname);
    }

    function element($qname, /*array*/ $arguments) {
        $this->string .= Xml::element($qname, $arguments);
    }    
    
    function characters($chars){
        $this->string .= $chars;
    }

    function html($html){
        $this->string .= $html;
    }
    
    function getContent() {
        return $this->string;
    }

}
